home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / djgpp / contrib / pdcurs22 / src / portable / kernel.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-26  |  11.1 KB  |  391 lines
  1. /*
  2. ***************************************************************************
  3. * This file comprises part of PDCurses. PDCurses is Public Domain software.
  4. * You may use this code for whatever purposes you desire. This software
  5. * is provided AS IS with NO WARRANTY whatsoever.
  6. * Should this software be used in another application, an acknowledgement
  7. * that PDCurses code is used would be appreciated, but is not mandatory.
  8. *
  9. * Any changes which you make to this software which may improve or enhance
  10. * it, should be forwarded to the current maintainer for the benefit of 
  11. * other users.
  12. *
  13. * The only restriction placed on this code is that no distribution of
  14. * modified PDCurses code be made under the PDCurses name, by anyone
  15. * other than the current maintainer.
  16. * 
  17. * See the file maintain.er for details of the current maintainer.
  18. ***************************************************************************
  19. */
  20. #define    CURSES_LIBRARY    1
  21. #include <curses.h>
  22.  
  23. #ifndef NO_MEMORY_H
  24. #include <memory.h>
  25. #endif
  26.  
  27. #ifdef UNIX
  28. #include <defs.h>
  29. #include <term.h>
  30. #endif
  31.  
  32. /* undefine any macros for functions defined in this module */
  33. #undef    def_prog_mode
  34. #undef    def_shell_mode
  35. #undef    reset_prog_mode
  36. #undef    reset_shell_mode
  37. #undef    resetty
  38. #undef    savetty
  39. #undef    getsyx
  40. #undef    setsyx
  41. #undef    ripoffline
  42. #undef    curs_set
  43. #undef    napms
  44.  
  45. /* undefine any macros for functions called by this module if in debug mode */
  46. #ifdef PDCDEBUG
  47. #  undef    move
  48. #  undef    wmove
  49. #endif
  50.  
  51. #ifdef PDCDEBUG
  52. char *rcsid_kernel  = "$Id$";
  53. #endif
  54.  
  55. /*man-start*********************************************************************
  56.  
  57.   Name:                                                        kernel
  58.  
  59.   Synopsis:
  60.       int def_prog_mode(void);
  61.       int def_shell_mode(void);
  62.       int reset_prog_mode(void);
  63.       int reset_shell_mode(void);
  64.       int resetty(void);
  65.       int savetty(void);
  66.   ***    int getsyx(int y, int x);
  67.   ***    int setsyx(int y, int x);
  68.   ***    int ripoffline(int line, init(*int)(WINDOW *,int));
  69.       int curs_set(int visibility);
  70.       int napms(int ms);
  71.  
  72.   X/Open Description:
  73.      The def_prog_mode() and def_shell_mode() functions save the 
  74.      current terminal modes as the "program" (in curses) or
  75.      "shell" (not in curses) state for use by the reset_prog_mode()
  76.      and reset_shell_mode() functions.  This is done automatically by
  77.      initscr().
  78.  
  79.      The reset_prog_mode() and reset_shell_mode() functions restore 
  80.      the terminal to "program" (in curses) or "shell" (not in curses)
  81.      state.  These are done automatically by endwin()
  82.      and doupdate() after an endwin(), so they would normally not
  83.      be called before these functions.
  84.  
  85.      The savetty() and resetty() routines save and restore the state of 
  86.      the terminal modes. The savetty() function saves the current state 
  87.      in a buffer and resetty() restores the state to what it was at the 
  88.      last call to savetty().
  89.  
  90.   PDCurses Description:
  91.      FYI: It is very unclear whether savetty() and resetty() functions
  92.      are a duplication of the reset_prog_mode() and reset_shell_mode() 
  93.      functions or whether this is a backing store type of operation.  
  94.      At this time, they are implemented similar to the reset_*_mode() 
  95.      routines.
  96.  
  97.      The curs_set() routine is used to set the visibility of the cursor.
  98.      The cursor can be made invisible, normal or highly visible by setting
  99.      the parameter to 0, 1 or 2 respectively. If an invalid value is passed
  100.      the function will set the cursor to "normal".
  101.  
  102.   X/Open Return Value:
  103.      All functions return OK on success and ERR on error except curs_set()
  104.      which returns the previous visibility.
  105.  
  106.   X/Open Errors:
  107.      No errors are defined for this function.
  108.  
  109.   Portability                             X/Open    BSD    SYS V
  110.                                           Dec '88
  111.       def_prog_mode                         Y        Y       Y
  112.       def_shell_mode                        Y        Y       Y
  113.       reset_prog_mode                       Y        Y       Y
  114.       reset_shell_mode                      Y        Y       Y
  115.       resetty                               Y        Y       Y
  116.       savetty                               Y        Y       Y
  117.       getsyx                                -        -      3.0
  118.       setsyx                                -        -      3.0
  119.       ripoffline                            -        -      3.0
  120.       curs_set                              -        -      3.0
  121.       napms                                 Y        Y       Y
  122.  
  123. **man-end**********************************************************************/
  124.  
  125. #ifndef UNIX
  126. /***********************************************************************/
  127. int    def_prog_mode(void)
  128. /***********************************************************************/
  129. {
  130. #ifdef PDCDEBUG
  131.     if (trace_on) PDC_debug("def_prog_mode() - called\n");
  132. #endif
  133.  
  134. #ifdef    FLEXOS
  135.     _flexos_16bitmode();
  136. #endif
  137.     c_pr_tty.been_set = TRUE;
  138.  
  139.     memcpy(&c_pr_tty.saved, &_cursvar, sizeof(SCREEN));
  140.  
  141.     return( OK );
  142. }
  143. #endif
  144.  
  145. #ifndef UNIX
  146. /***********************************************************************/
  147. int    def_shell_mode(void)
  148. /***********************************************************************/
  149. {
  150. #ifdef PDCDEBUG
  151.     if (trace_on) PDC_debug("def_shell_mode() - called\n");
  152. #endif
  153.  
  154. #ifdef    FLEXOS
  155.     _flexos_8bitmode();
  156. #endif
  157.     c_sh_tty.been_set = TRUE;
  158.  
  159.     memcpy(&c_sh_tty.saved, &_cursvar, sizeof(SCREEN));
  160.  
  161.     return( OK );
  162. }
  163. #endif
  164.  
  165. #ifndef UNIX
  166. /***********************************************************************/
  167. int    reset_prog_mode(void)
  168. /***********************************************************************/
  169. {
  170. #ifdef PDCDEBUG
  171.     if (trace_on) PDC_debug("reset_prog_mode() - called\n");
  172. #endif
  173.  
  174.     if    (c_pr_tty.been_set == TRUE)
  175.     {
  176.  
  177.         memcpy(&_cursvar, &c_pr_tty.saved, sizeof(SCREEN));
  178.  
  179.         mvcur(0, 0, c_pr_tty.saved.cursrow, c_pr_tty.saved.curscol);
  180.         if (PDC_get_ctrl_break() != c_pr_tty.saved.orgcbr)
  181.             PDC_set_ctrl_break(c_pr_tty.saved.orgcbr);
  182.         if (c_pr_tty.saved.raw_out)
  183.             raw();
  184.         if (c_pr_tty.saved.visible_cursor)
  185.             PDC_cursor_on();
  186.         _cursvar.font = PDC_get_font();
  187.         PDC_set_font(c_pr_tty.saved.font);
  188. #if !defined (XCURSES)
  189. #  ifndef EMXVIDEO
  190.         if (!PDC_scrn_modes_equal (PDC_get_scrn_mode(),  c_pr_tty.saved.scrnmode))
  191.             PDC_set_scrn_mode(c_pr_tty.saved.scrnmode);
  192. #  endif
  193. #endif
  194.         PDC_set_rows(c_pr_tty.saved.lines);
  195.     }
  196. #ifdef    FLEXOS
  197.     _flexos_16bitmode();
  198. #endif
  199.     return( OK );
  200. }
  201. #endif
  202.  
  203. #ifndef UNIX
  204. /***********************************************************************/
  205. int    reset_shell_mode(void)
  206. /***********************************************************************/
  207. {
  208. #ifdef PDCDEBUG
  209.     if (trace_on) PDC_debug("reset_shell_mode() - called\n");
  210. #endif
  211.  
  212.     if    (c_sh_tty.been_set == TRUE)
  213.     {
  214.  
  215.         memcpy(&_cursvar, &c_sh_tty.saved, sizeof(SCREEN));
  216.  
  217.         mvcur(0, 0, c_sh_tty.saved.cursrow, c_sh_tty.saved.curscol);
  218.         if (PDC_get_ctrl_break() != c_sh_tty.saved.orgcbr)
  219.             PDC_set_ctrl_break(c_sh_tty.saved.orgcbr);
  220.         if (c_sh_tty.saved.raw_out)
  221.             raw();
  222.         if (c_sh_tty.saved.visible_cursor)
  223.             PDC_cursor_on();
  224.         _cursvar.font = PDC_get_font();
  225.         PDC_set_font(c_sh_tty.saved.font);
  226. #if !defined (XCURSES)
  227. #  ifndef EMXVIDEO
  228.         if (!PDC_scrn_modes_equal (PDC_get_scrn_mode(),  c_sh_tty.saved.scrnmode))
  229.             PDC_set_scrn_mode(c_sh_tty.saved.scrnmode);
  230. #  endif
  231. #endif
  232.         PDC_set_rows(c_sh_tty.saved.lines);
  233.     }
  234. #ifdef    FLEXOS
  235.     _flexos_8bitmode();
  236. #endif
  237.     return( OK );
  238. }
  239. #endif
  240.  
  241. /***********************************************************************/
  242. int    resetty(void)
  243. /***********************************************************************/
  244. {
  245. #ifdef PDCDEBUG
  246.     if (trace_on) PDC_debug("resetty() - called\n");
  247. #endif
  248.  
  249. #ifndef UNIX
  250.     if    (c_save_tty.been_set == TRUE)
  251.     {
  252.         memcpy(&_cursvar, &c_save_tty.saved, sizeof(SCREEN));
  253.  
  254.         mvcur(0, 0, c_save_tty.saved.cursrow, c_save_tty.saved.curscol);
  255.         if (PDC_get_ctrl_break() != c_save_tty.saved.orgcbr)
  256.             PDC_set_ctrl_break(c_save_tty.saved.orgcbr);
  257.         if (c_save_tty.saved.raw_out)
  258.             raw();
  259.         if (c_save_tty.saved.visible_cursor)
  260.             PDC_cursor_on();
  261.         _cursvar.font = PDC_get_font();
  262.         PDC_set_font(c_save_tty.saved.font);
  263. #if !defined (XCURSES)
  264. #  ifndef EMXVIDEO
  265.         if (!PDC_scrn_modes_equal (PDC_get_scrn_mode(), c_save_tty.saved.scrnmode))
  266.             PDC_set_scrn_mode(c_save_tty.saved.scrnmode);
  267. #  endif
  268. #endif
  269.         PDC_set_rows(c_save_tty.saved.lines);
  270.     }
  271. #endif
  272.     return( c_save_tty.been_set ? OK : ERR );
  273. }
  274. /***********************************************************************/
  275. int    savetty(void)
  276. /***********************************************************************/
  277. {
  278. #ifdef PDCDEBUG
  279.     if (trace_on) PDC_debug("savetty() - called\n");
  280. #endif
  281.  
  282.     c_save_tty.been_set = TRUE;
  283.     memcpy(&c_save_tty.saved, &_cursvar, sizeof(SCREEN));
  284.     return( OK );
  285. }
  286. /***********************************************************************/
  287. int    curs_set(int visibility)
  288. /***********************************************************************/
  289. {
  290. #ifdef OS2
  291. # ifndef EMXVIDEO
  292.  VIOCURSORINFO pvioCursorInfo;
  293. # endif
  294. #endif
  295.  int start,end,hidden=0;
  296.  int ret_vis;
  297.  
  298. #ifdef PDCDEBUG
  299.     if (trace_on) PDC_debug("curs_set() - called: visibility=%d\n",visibility);
  300. #endif
  301.  
  302.     ret_vis = _cursvar.visibility;
  303.     _cursvar.visibility = visibility;
  304.  
  305. #ifdef UNIX
  306.     switch(visibility)
  307.     {
  308.         case 0:  /* invisible */
  309.             if (cursor_invisible != NULL)
  310.                 putp(cursor_invisible);
  311.             break;
  312.         case 2:  /* highly visible */
  313.             if (cursor_visible != NULL)
  314.                 putp(cursor_visible);
  315.             break;
  316.         default:  /* normal visibility */
  317.             if (cursor_visible != NULL)
  318.                 putp(cursor_visible);
  319.             break;
  320.     }
  321.     return(OK);
  322. #endif
  323.  
  324. #if defined(DOS) || defined(OS2)
  325.     switch(visibility)
  326.     {
  327.         case 0:  /* invisible */
  328. # ifdef OS2
  329. #  ifdef EMXVIDEO
  330.             start = end = 0;
  331. #  else
  332.             start = _cursvar.font / 4;
  333.             end = _cursvar.font;
  334. #  endif
  335. # else
  336.             start = 32;
  337.             end = 32;  /* was 33 */
  338. # endif
  339.             hidden = (-1);
  340.             break;
  341.         case 2:  /* highly visible */
  342.             start = 2;   /* almost full-height block */
  343.             end = _cursvar.font-1;
  344.             break;
  345.         default:  /* normal visibility */
  346.             start = _cursvar.font - 4;
  347.             end = _cursvar.font-1;
  348.             break;
  349.     }
  350.  
  351. # ifdef OS2
  352. #  ifdef EMXVIDEO
  353.     if (hidden)
  354.         v_hidecursor();
  355.     else
  356.         v_ctype (start, end);
  357. #  else
  358.     pvioCursorInfo.yStart = (USHORT)start;
  359.     pvioCursorInfo.cEnd = (USHORT)end;
  360.     pvioCursorInfo.cx = (USHORT)1;
  361.     pvioCursorInfo.attr = hidden;
  362.     VioSetCurType((PVIOCURSORINFO)&pvioCursorInfo,0);
  363. #  endif
  364. # endif
  365.  
  366. # ifdef DOS
  367.     regs.h.ah = 0x01;
  368.     regs.h.al = (unsigned char)_cursvar.scrnmode;  /* if not set, some BIOSes hang */
  369.     regs.h.ch = (unsigned char)start;
  370.     regs.h.cl = (unsigned char)end;
  371.     int86(0x10, ®s, ®s);
  372. # endif
  373.     return( ret_vis );
  374. #endif
  375.  
  376. #if defined (XCURSES)
  377.     XCurses_display_cursor(_cursvar.cursrow,_cursvar.curscol,
  378.         curscr->_y[_cursvar.cursrow][_cursvar.curscol],
  379.         _cursvar.cursrow,_cursvar.curscol,
  380.         curscr->_y[_cursvar.cursrow][_cursvar.curscol]);
  381.     return(ret_vis);
  382. #endif
  383.  
  384. }
  385. /***********************************************************************/
  386. int    napms(int ms)
  387. /***********************************************************************/
  388. {
  389.     return(delay_output(ms));
  390. }
  391.